#include "gui.h"

//Ces variables globales sont mises ici parce que de toute facon,
//GUI_init doit etre le premier a leur coller une valeur
GtkWidget* fenetre=NULL;
GtkWidget* fenetre_vbox=NULL;
GtkWidget* debug_label=NULL;
GtkWidget* container_monde=NULL;
GtkWidget* container_aeroport=NULL;
GtkWidget* regenerer_spin_box=NULL;
//lancement de la simulation
gboolean simulation_can_run = FALSE;
GtkWidget* sim_vitesse_spin=NULL;
gboolean simulation_started=FALSE;
GtkWidget* g_monde = NULL;
GtkWidget* g_aeroport = NULL;
GooCanvasItem* r_monde = NULL;
GooCanvasItem* r_aeroport = NULL;
GooCanvasItem* groupe_monde = NULL;
gboolean gui_started=FALSE;
char _settings[MAX_SETTINGS][2][MAX_SETTING_LENGTH];
int _nb_settings=0;

//Scrolling & Zoom
gboolean mouse_down=FALSE;
int _x=50;
int _y=50;
gdouble last_mouse_x=-1;
gdouble last_mouse_y=-1;
gdouble last_mouse_dist=-1;
GtkAdjustment* hadj;
GtkAdjustment* vadj;
gdouble hadj_max;
gdouble hadj_min;
gdouble vadj_max;
gdouble vadj_min;
gdouble hpage_size=-1;
gdouble vpage_size=-1;
GtkWidget* toolbar_bas=NULL;


//modes (boutons toggle & possibilités clic)
//mis à 0 normalement
gboolean mode_deplacement=FALSE;
gboolean mode_selection=TRUE;
gboolean mode_zoom=FALSE;
GtkWidget* bouton_zoom;
GtkWidget* bouton_selection;
GtkWidget* bouton_deplacer;
//navigation haut
GtkWidget* regenerer_dialogue=NULL;

//elements
GooCanvasItem** goo_avions=NULL;
GooCanvasItem** goo_aeroports=NULL;
int ancien_nb_avions=0;
int ancien_nb_aeroports=0;

//avancement simulation
gdouble simulation_current_ut=0;
gdouble simulation_max_ut=0;
GtkWidget* date_label=NULL;

//labels vue aerpot
GtkWidget* label_avions_vol=NULL;
GtkWidget*label_avions_decollage=NULL;
GtkWidget*label_avions_atterrissage=NULL;
GtkWidget*label_avions_parking=NULL;
GtkWidget*dialogue_info_aero=NULL;


//xdepart,ydepart -> xarrivee,yarrivee
gdouble distance(gdouble x1, gdouble y1, gdouble x2, gdouble y2)
{
	return (gdouble)sqrt(pow(x2-x1,2) + pow(y2-y1,2));
}

gboolean on_motion_notify(GtkWidget*item,GtkAdjustment*target,GdkEventMotion*event,gpointer data)
{
	gdouble x_offset, y_offset;
	gdouble x_val,y_val; // valeurs pour le panning
	gdouble x_z, y_z; //valeurs pour le zoom
	gdouble hvalue,vvalue;
	gdouble slow_rate = 5;
	gdouble signe;
	gdouble echelle;
	gdouble distance_offset;
	if(mouse_down && (mode_zoom || mode_deplacement))
	{
		if(last_mouse_x == -1 || last_mouse_y == -1 || last_mouse_dist == -1)
		{
			last_mouse_x = event->x;
			last_mouse_y = event->y;
			last_mouse_dist = distance(event->x,event->y,hpage_size/2,vpage_size/2);
		}
		x_offset = (event->x -last_mouse_x)/slow_rate;
		y_offset = (event->y - last_mouse_y)/slow_rate;
		hvalue = gtk_adjustment_get_value(hadj);
		vvalue = gtk_adjustment_get_value(vadj);

		if(mode_zoom)
		{
			//si va vers l'exterieur (les offsets sont de meme signe
			distance_offset = last_mouse_dist -  distance(event->x,event->y,hpage_size/2,vpage_size/2);
			signe = distance_offset > 0 ? 1 : -1;
			echelle = goo_canvas_get_scale(GOO_CANVAS(g_monde));
			echelle = echelle+signe*0.01;
			if(echelle <= MAX_ZOOM_SCALE && echelle >= MIN_ZOOM_SCALE)
				goo_canvas_set_scale(GOO_CANVAS(g_monde),echelle);//(MAX_ZOOM_SCALE/echelle)*distance_offset/WIDTH //distance_offset/(hpage_size/2)
			else if(echelle > MAX_ZOOM_SCALE)
				goo_canvas_set_scale(GOO_CANVAS(g_monde),MAX_ZOOM_SCALE);
			else
				goo_canvas_set_scale(GOO_CANVAS(g_monde),MIN_ZOOM_SCALE);
			msg("echelle:%d/100\n",(int)(echelle*100));
		}
		else if(mode_deplacement)
		{
			x_val = hvalue-x_offset;
			y_val = vvalue-y_offset;
			//ajudstment vesrtical
			if(x_val > hadj_max)
			{
				x_val = hadj_max;
			}
			else if (x_val < hadj_min)
			{
				x_val = hadj_min;
			}
			//ajustemaent horizontal
			if(y_val > vadj_max)
				y_val = vadj_max;
			else if (y_val < vadj_min)
				y_val = vadj_min;
			gtk_adjustment_set_value(hadj,x_val);
			gtk_adjustment_changed(hadj);
			gtk_adjustment_set_value(vadj,y_val);
			gtk_adjustment_changed(vadj);
		}
	}
	return FALSE;
}

gboolean on_press(GooCanvasItem*item,GooCanvasItem*target,GdkEventButton*event,gpointer data)
{
	g_print("mouse_pressed\n");
	mouse_down = TRUE;
	return FALSE;
}

gboolean on_release(GooCanvasItem*item,GooCanvasItem*target,GdkEventButton*event,gpointer data)
{
	gdouble echelle;
	g_print("mouse_released\n");
	mouse_down = FALSE;
	last_mouse_x = last_mouse_y = -1;
	last_mouse_dist = -1;
	echelle = goo_canvas_get_scale(GOO_CANVAS(g_monde));
	if(echelle > MAX_ZOOM_SCALE)
		goo_canvas_set_scale(GOO_CANVAS(g_monde),MAX_ZOOM_SCALE);
	else if(echelle < MIN_ZOOM_SCALE)
		goo_canvas_set_scale(GOO_CANVAS(g_monde),MIN_ZOOM_SCALE);
	return FALSE;
}

gboolean set_scroll_limits(GtkWidget*emitter,GtkWidget*target,GdkEvent*evt,gpointer data)
{
	g_object_get(hadj,"lower",&hadj_min,"upper",&hadj_max);
	g_object_get(vadj,"lower",&vadj_min,"upper",&vadj_max);
	g_object_get(hadj,"page-size",&hpage_size);
	g_object_get(vadj,"page-size",&vpage_size);
	hadj_max = hadj_max - hpage_size;
	vadj_max = vadj_max - vpage_size;
	//g_printf("did set LIMITS : horiz[%f,%f],vertic%f,%f\n",hadj_min,hadj_max,vadj_min,vadj_max);
	return FALSE;
}



#if 1
gboolean move_pic(gpointer gciImage)
{
	_x += 1;
	_y += 1;
	msg("x,y:%d,%d\n",_x,_y);
	goo_canvas_item_set_simple_transform(GOO_CANVAS_ITEM(gciImage),_x,_y,1,0);
	return TRUE;
}
#endif

//glade_filename == NULL => default : "GUI.glade"
int GUI_init(int* argc,char*** argv)
{
	GladeXML *xml;
	int success;
	//init gtk
	gtk_init(argc, argv);

	success = set_settings_file(SETTINGS_FILENAME);
	if(!success)
	{
		msg("GUI_init:je ne peux travailler sans %s\n",SETTINGS_FILENAME);
	}
	//chargement xml
	xml = glade_xml_new(get_setting("glade"), NULL, NULL);
	if(!xml)
	{
		//message d'erreur de GTK automatique ici
		exit(0);
	}
	/* connect the signals in the interface */
	glade_xml_signal_autoconnect(xml);

	//fenetre principale
	fenetre = glade_xml_get_widget(xml,"fenetre");

	//container des deux vues
	container_monde = glade_xml_get_widget(xml,"container_monde");
	container_aeroport = glade_xml_get_widget(xml,"container_aeroport");
	bouton_zoom = glade_xml_get_widget(xml,"outil_zoomer");
	bouton_selection = glade_xml_get_widget(xml,"outil_selection");
	bouton_deplacer = glade_xml_get_widget(xml,"outil_decaler");
	sim_vitesse_spin = glade_xml_get_widget(xml,"sim_vitesse_spin");
	date_label = glade_xml_get_widget(xml,"date_label");
	regenerer_dialogue = glade_xml_get_widget(xml,"regenerer_dialogue");
	regenerer_spin_box = glade_xml_get_widget(xml,"regenerer_spin_box");
	toolbar_bas = glade_xml_get_widget(xml,"toolbar_bas");
	dialogue_info_aero = glade_xml_get_widget(xml,"dialogue_info_aero");
	//contenu_vue_aeroport = glade_xml_get_widget(xml,"contenu_vue_aeroport"); //INUTILE

	label_avions_vol = glade_xml_get_widget(xml,"label_avions_vol");
	label_avions_decollage = glade_xml_get_widget(xml,"label_avions_decollage");
	label_avions_atterrissage = glade_xml_get_widget(xml,"label_avions_atterrissage");
	label_avions_parking = glade_xml_get_widget(xml,"label_avions_parking");
	gtk_widget_set_sensitive(toolbar_bas,FALSE);

	//canevas monde et aeroport
	g_monde = goo_canvas_new();
	g_aeroport = goo_canvas_new();

	//configuration des canevas
	gtk_widget_set_size_request(g_monde,WIDTH*MONDE_SCALE_FACTOR,HEIGHT*MONDE_SCALE_FACTOR);
	goo_canvas_set_bounds(GOO_CANVAS(g_monde),0,0,WIDTH*MONDE_SCALE_FACTOR,HEIGHT*MONDE_SCALE_FACTOR);
	goo_canvas_set_bounds(GOO_CANVAS(g_aeroport),0,0,1000,1000);
	hadj = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(container_monde));
	vadj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(container_monde));
	
	//a lancer un peu après le lancement de l'application
	g_signal_connect(g_monde,"expose-event",(GtkSignalFunc)set_scroll_limits,NULL);

	
	gtk_widget_show(g_monde);
	gtk_widget_show(g_aeroport);

	//prise des racines dessinables
	r_monde = goo_canvas_get_root_item(GOO_CANVAS(g_monde));
	r_aeroport = goo_canvas_get_root_item(GOO_CANVAS(g_aeroport));
	groupe_monde = goo_canvas_group_new(r_monde,NULL);
	
	//ajout dans les container des deux vues
	gtk_container_add(GTK_CONTAINER(container_monde),g_monde);
	gtk_container_add(GTK_CONTAINER(container_aeroport),g_aeroport);

	#if 1
	//dessin DE LA VUE MONDE SEULEMENT
	success = dessiner_monde();
	if(!success)
	{
		msg("GUI_init : echec de dessin_monde()\n");
		//return 0; //on fait lancer l'interface graphique quand meme
	}
	#endif

	/*
	//placement des points aeroports
	placer_points();
	//creation des avions		//VIEUX
	creer_avions();*/
	
	//label de debuggage
	#if defined DEBUG && defined USE_GUI
	fenetre_vbox = glade_xml_get_widget(xml,"fenetre_vbox");
	debug_label = gtk_label_new("");
	gtk_box_pack_start(GTK_BOX(fenetre_vbox),debug_label,FALSE,TRUE,0);
	#endif
	//gtk_window_maximize(GTK_WINDOW(fenetre)); //pas de mode plein ecran
	gtk_widget_show_all(fenetre);

	/* start the event loop */
	gui_started = TRUE;
	gtk_main();
	return 1;
}

//requiert GUI_init appelé
int dessiner_monde()
{
	GdkPixbuf* fp=NULL;
	GooCanvasItem* fond=NULL;
	GError* erreur=NULL;

	fond = image_item(groupe_monde,"fond_monde",WIDTH*MONDE_SCALE_FACTOR,HEIGHT*MONDE_SCALE_FACTOR,0,0);

	#if 1
	#if 0
	//ouverture fichier
	fp = gdk_pixbuf_new_from_file_at_scale(get_setting("fond_monde"),WIDTH*MONDE_SCALE_FACTOR,HEIGHT*MONDE_SCALE_FACTOR,FALSE,&erreur);

	if(erreur)
	{
		msg("dessiner_monde:%s\n",erreur->message);
		g_error_free(erreur);

		return 0;
	}


	//creation canvas item et écriture sur root
	fond = goo_canvas_image_new(groupe_monde,fp,0,0);//"width",(gdouble)WIDTH*2,"height",(gdouble)HEIGHT*2,NULL);
	#endif
	g_signal_connect(fond,"motion_notify_event",(GtkSignalFunc)on_motion_notify,NULL);
	g_signal_connect(fond,"button_press_event",(GtkSignalFunc)on_press,NULL);
	g_signal_connect(fond,"button_release_event",(GtkSignalFunc)on_release,NULL);
	//goo_canvas_item_set_simple_transform(r_monde,0,0,1,0);
	//g_timeout_add(100,move_pic,fond); // tous les dixièmes de seconde
	#endif

	return 1;
}

//w,h = (0,0) => taille d'origine
GooCanvasItem* image_item(GooCanvasItem* root_canvas,char* setting_name,int width,int height,int x,int y)
{

	GooCanvasItem* a=NULL;
	GdkPixbuf* b=NULL;
	GError* erreur=NULL;
	char* nom_fichier=NULL;
	nom_fichier = get_setting(setting_name);
	if(!nom_fichier)
	{
		msg("<===IMAGE_ITEM : %s pas un bon nom de setting",setting_name);
		return NULL;
	}
	msg("image_item : will use : %s->%s,width,height:%d,%d\n",setting_name,get_setting(setting_name),width,height);
	if(width<=0 || height <=0)
	{
		b = gdk_pixbuf_new_from_file(get_setting(setting_name),&erreur);
		msg("image_item : using default size for image\n");
	}
	else								//FALSE : pas de préserv de l'aspect ratio
	{
		b = gdk_pixbuf_new_from_file_at_scale(get_setting(setting_name),width,height,FALSE,&erreur);
		msg("image_item : using size: %d,%d\n",width,height);
	}
	msg("image_item:pixbuf chargé:%d,width:%d\n",b,gdk_pixbuf_get_width(b));
	if(erreur || !b)
	{
		msg("image_item:%s\n",erreur->message);
		g_error_free(erreur);
		return NULL;
	}
	msg("root_canvas : %d, pixbuf : %d, x,y:%f,%f\n",root_canvas,b,(gdouble)x,(gdouble)y);
	a = goo_canvas_image_new(root_canvas,b,(gdouble)x,(gdouble)y,NULL); //TODO : PROBLEME ici
	msg("pas d'erreur1111\n");
	goo_canvas_item_raise(a,NULL);
	msg("pas d'erreur\n");
	return a;
}

void destroy_item(GooCanvasItem*emitter)
{
		GooCanvasItemModel* model,*parent;
	gint child_num;
	/*
	model = goo_canvas_item_get_model( (GooCanvasItem*)emitter);
	msg("destroying_itemeazzea\n");
   parent = goo_canvas_item_model_get_parent (model);
   */
   msg("destroying_item\n");
   child_num = goo_canvas_item_find_child (groupe_monde,emitter);
   msg("destroying_itemaz\n");
   goo_canvas_item_remove_child (groupe_monde, child_num);
}

void hide_item(GooCanvasItem*item)
{
	msg("hiding item\n");
	g_object_set(G_OBJECT(item),"visibility",GOO_CANVAS_ITEM_INVISIBLE,NULL);
	msg("hiding done\n");
}

void show_item(GooCanvasItem*item)
{
	msg("showing_item\n");
	g_object_set(G_OBJECT(item),"visibility",GOO_CANVAS_ITEM_VISIBLE,NULL);
	msg("showing_done\n");
}

gboolean is_visible(GooCanvasItem*item)
{
	gboolean value;
	g_object_get(G_OBJECT(item),"visibility",&value,NULL);
	return value==GOO_CANVAS_ITEM_VISIBLE;
}

gboolean on_bulle_pressed(GooCanvasItem*bulle,GooCanvasItem*target,GdkEventButton*evt,gpointer rien)
{
	//quand la bulle est cliquée, on la supprime
	GooCanvasItem*label;
	gboolean* no;
	no = (gboolean*)malloc(sizeof(gboolean));
	*no = FALSE;
	if(mode_selection)
	{
		label = (GooCanvasItem*)g_object_get_data(G_OBJECT(bulle),"text_label");
		g_object_set_data(G_OBJECT(g_object_get_data(G_OBJECT(bulle),"parent")),"has_infobulle_yet",no);
		msg("destroying label\n");
		destroy_item(GOO_CANVAS_ITEM(label));
		msg("destroying bulle\n");
		destroy_item(GOO_CANVAS_ITEM(bulle));
	}
	
   return FALSE;

}

gboolean on_texte_bulle_pressed(GooCanvasItem*texte_bulle,GooCanvasItem*target,GdkEventButton*evt,gpointer rien)
{
	GooCanvasItem * bul;
	gboolean* no;
	no = (gboolean*)malloc(sizeof(gboolean));
	*no = FALSE;
	if(mode_selection)
	{
		bul = (GooCanvasItem*)g_object_get_data(G_OBJECT(texte_bulle),"parent");
		g_object_set_data(G_OBJECT(g_object_get_data(G_OBJECT(bul),"parent")),"has_infobulle_yet",no);
		msg("destroying label\n");
		destroy_item(GOO_CANVAS_ITEM(texte_bulle));
		msg("destroying bulle\n");
		destroy_item(GOO_CANVAS_ITEM(bul));
	}
	
   return FALSE;



}

//pas besoin d'utiliser le retour de la fonction
//NOTE : DANS LA VUE MONDE ON PEUT AVOIR DES INFORMATIOSN SUR LES AVIONS EN VOLS ET LES AEROPORTS
//DANS LA VUE AEROPORT : ON PEUT AVOIR DES INFORMATIONS SUR LES AVIONS SEULEMENT
GooCanvasItem* faire_info_bulle(int quelle_vue,GooCanvasItem*sur_quel_objet)
{
	//on aura toujours affaire pour les avions et les points aeroports a goo canvas image_item
	//donc on peut lire les prop x et y tranquillou
	gdouble x,y,w,h,x1,y1;
	GooCanvasItem* bul=NULL;
	GooCanvasItem* root=NULL;
	GooCanvasItem* goo_label=NULL;
	GtkWidget*label=NULL;
	GtkWidget*croix=NULL;
	gboolean* already_infobulle;

	already_infobulle = g_object_get_data(G_OBJECT(sur_quel_objet),"has_infobulle_yet");
	msg("already_infobulle:%d\n",*already_infobulle);
	if(!(*already_infobulle))
	{
		*already_infobulle=TRUE;
		g_object_set_data(G_OBJECT(sur_quel_objet),"has_infobulle_yet",already_infobulle);
		//on prend la position de l'objezt
		msg("avant\n");
		g_object_get(sur_quel_objet,"x",&x,"y",&y,NULL);
		msg("apres\n");
		msg("x,y:%f,%f\n",x,y);
		//si on est dans la vue aéroport
		//alors c'est simple, le truc ne peut être qu'un avion
		if(quelle_vue == VUE_AEROPORT)
		{
			root = r_aeroport;
		}
		else
		{
			root = groupe_monde;
		}
		//creation de la bulle
		bul = image_item(root,"infobulle",0,0,x,y);
		msg("creer info_bulle\n");
		g_object_get(bul,"x",&x,"y",&y,"width",&w,"height",&h,NULL);
		msg("x,y:%f,%f,w,h:%f,%f\n",x,y,w,h);
		x1 = x-w/2; y1=y-h/2;
		goo_canvas_item_set_simple_transform(bul,x,y,1,0);
		goo_label = goo_canvas_text_new(groupe_monde,"bonjour",x,y,-1,GTK_ANCHOR_CENTER,NULL);//GTK_ANCHOR_NORTH_WEST
		goo_canvas_item_raise(goo_label,NULL);

		g_object_set_data(G_OBJECT(bul),"nature","infobulle");
		g_object_set_data(G_OBJECT(bul),"text_label",goo_label);
		g_object_set_data(G_OBJECT(bul),"parent",sur_quel_objet);
		g_object_set_data(G_OBJECT(goo_label),"parent",bul);
		g_signal_connect(bul,"button_press_event",(GtkSignalFunc)on_bulle_pressed,NULL);
		g_signal_connect(goo_label,"button_press_event",(GtkSignalFunc)on_texte_bulle_pressed,NULL);
		
		//callbacks frequents pour qu'il y ait du refresh (jusqu'à ce que la bulle soit fermée)

		//configuration callback fermeture bulle => destruction bulle
	}
	return bul;
}

gboolean on_point_aeroport_presse(GooCanvasItem*aeroport,GooCanvasItem*target,GdkEventButton*event,gpointer data)
{
	if(mode_selection)
	{
		faire_info_bulle(VUE_MONDE,aeroport);
	}
}

//pas nécessaire d'utiliser le retour de cette fct
GooCanvasItem* nouveau_point(int x,int y,int id_aeroport)
{
	int *id;
	gboolean* yes;
	GooCanvasItem* point;

	id = (int*)calloc(1,sizeof(int));
	*id = id_aeroport; // => pas de free de ce pointeur !
	yes = (gboolean*)malloc(sizeof(gboolean));
	*yes = FALSE;
	msg("nouveau_point : je mettrai le point a x,y : %d,%d\n",x,y);
	point=image_item(groupe_monde,"point_aeroport",0,0,x,y);

	msg("nouveau_point:OIHJOIHE\n");
	//ajout d'une donnee sur l'aeroport
	msg("nouveau_point:tout ok j'usqui'ic\n");
	g_object_set_data(G_OBJECT(point),"nature","aeroport");
	g_object_set_data(G_OBJECT(point),"id",id);
	g_object_set_data(G_OBJECT(point),"has_infobulle_yet",yes);
	msg("nouveau_point:pas de probleme\n");
	//configuration du callback pour ca affiche les donnees sur un aeroport precis
	g_signal_connect(point,"button_press_event",(GtkSignalFunc)on_point_aeroport_presse,NULL);

	return point;
}

//UNE FONCTION CONVERSION COORDS ICI (x,y structures => x,y dessin)
//ET UNE AUTRE FONCTION : (aeroport depart, aeroport arrivee, pourcentage accompli => x,y)

void placer_points()
{

	//NOTE: on utilise lezs varaibles globales aeroports (de type t_aeroport**) et nb_aeroports (int)
	int a;
	int x,y;
	int x1,y1; // coords converties

	if(goo_aeroports == NULL)
	{
		goo_aeroports = (GooCanvasItem**)calloc(variables->nbaero,sizeof(GooCanvasItem*));
		for(a=0;a<variables->nbaero;a++)
		{
			goo_aeroports[a] = NULL;
		}
		ancien_nb_aeroports = variables->nbaero;
	}
	else
	{
		for(a=0;a<ancien_nb_aeroports;a++)
		{
			destroy_item(goo_aeroports[a]);
		}
		free(goo_aeroports);
		goo_aeroports = NULL;
		ancien_nb_aeroports= 0;
	}
	//balayer la liste des aeroporst
	for(a=0;a<variables->nbaero;a++)
	{
		//choper les coordonnees de l'aeroport
		//<======== TODO => CONVERSION DES COORDONNEES !!!!!!!!!!!!! ======>
		x = variables->aeroport[a]->x;
		y = variables->aeroport[a]->y;
		msg("placer_points:nom_aeroport:%s\n",variables->aeroport[a]->nom_aero);
		
		//traduire ces coordonnees pour nos graphismes
		//NOTE : WIDTH*MONDE_SCALE_FACTOR,HEIGHT*MONDE_SCALE_FACTOR,FALSE
		//=>on obtient x1 et x2
		x1 = x;
		y1 = y;
		//creer 1 pt à ces coordonnees
		msg("placer_points:will place %d,%d. id:%d\n",x1,y1,a);
		goo_aeroports[a] = nouveau_point(x1,y1,a);
	}
}


//NOTE on met a jour l'affichage de vraiment tous les avions
//NOTE : on n'a pas besoin de mettre à jour les aéroports / c'est des points ou des pistes...
void maj_affichage_avions()
{
	int a;
	int id_depart,id_arrivee;
	gdouble x1,y1,x2,y2;
	gdouble X,Y;
	gdouble distx,disty;
	gdouble pente;
	gdouble orientation;
	float avancement;
	t_avion* structure=NULL;
	GooCanvasItem* avion=NULL;
	GooCanvasItem* point_depart,*point_arrivee;
	msg("maj_affichage_avions : AFFICAHGE: maj_affichage_avions\n");
	//on balaye la liste des graphiques de la vue monde
	for(a=0;a<variables->avions_siml;a++)
	{
		avion = goo_avions[a];
		msg("maj_affichage_avions:avion:%d\n",avion);
		structure = (t_avion*)g_object_get_data(G_OBJECT(avion),"structure");
		msg("maj_affichage_avions:structure->sol_air:%d\n",structure->sol_air);
		//si l'avion est en l'air (pas près d'un aéroport)
		if(structure->sol_air == 1)
		{
			msg("maj_affichage_avions: avion en l'air : id:%d\n",a);
			//si l'avion n'est pourtant pas visible alors qu'il devrai letre
			if(!is_visible(avion))
			{
				msg("maj_affichage_avions : on rend l'avion %d visible\n",a);
				show_item(avion);
			}

			//recuperation des aeroports de provenance et de direction (étape précédente et étape prochaine)
			id_depart = structure->depart;
			id_arrivee = structure->arrivee;
			point_depart = goo_aeroports[id_depart];
			point_arrivee = goo_aeroports[id_arrivee];
			//récupération des coordonnées des aéroport
			msg("point_depart:id:%d,pt:%d,point_arrivee:id:%d,pt:%d\n",id_depart,point_depart,id_arrivee,point_arrivee);
			g_object_get(point_depart,"x",&x1,"y",&y1,NULL);
			g_object_get(point_arrivee,"x",&x2,"y",&y2,NULL);
			avancement = ((float)structure->y)/100.0; // chope l'avancement
			//calculs pour déterminer les coordonnées de l'avion
			distx = x2-x1; disty = y2-y1;
			Y = y1 + disty*avancement;
			X = x1 + distx*avancement;
			//angle
			orientation = 180.0*atan2(disty,distx)/M_PI; // on abien disty, distx en parametre. atan2 E [-pi,pi]]
			//application a l'avion
			msg("maj_affichage_avions : AVION %d : x,y,rot:%f,%f,%f\n",a,X,Y,orientation);
			goo_canvas_item_set_simple_transform(GOO_CANVAS_ITEM(avion),X,Y,1.0,orientation);
		}
		//si l'avion n'est pas en l'air, c'est qu'il est au sol
		else
		{
			msg("avion au sol!\n");
			//si l'avion est visible, on le cache
			if(is_visible(avion))
			{
				hide_item(avion);
			}
		}
	}
}

//pas obligé d'utiliser la valeur du retour
GooCanvasItem* creer_avion(t_avion* avion)
{
	GooCanvasItem* a;
	int type_avion; //le type de l'avion qu'on lit dans la structure
	char* nom_image_avion; // le nom d'identifiatn (setting_name) correspondant à ce type d'avion
	type_avion = avion->caburant;
	switch(type_avion)
	{
		case 15000: //ex: A 380
			nom_image_avion = strdup("boeing");
			break;
		case 10000: //ex boeing
			nom_image_avion = strdup("airbus");
			break;
		case 8000: //ex : jet
			nom_image_avion = strdup("jet");
			break;
		default:
			msg("creer_avion : %d -> type d'avion non reconnu !\n");
	}

	//dessin d'un avion dans chaque vue
	a = image_item(groupe_monde,nom_image_avion,0,0,0,0);
	//on lui passe un lien vers sa structure asociée
	g_object_set_data(G_OBJECT(a),"structure",avion);
	goo_canvas_item_raise(a,NULL);
	free(nom_image_avion);
	return a;
}

//note : on cree tous les avions, pas un seul
void creer_avions()
{
	//choper tableau d'avions du coeur
	int a;
	if(goo_avions == NULL)
	{
		msg("creer_avions : goo_avions==NULL : c'est la premiere qu'on cree des avions\n");
		goo_avions = (GooCanvasItem**)calloc(variables->avions_siml,sizeof(GooCanvasItem*));
		msg("CREER_AVIONS:variables->avions_siml(nbavions):%d\n",variables->avions_siml);
		for(a=0;a<variables->avions_siml;a++)
			goo_avions[a] = NULL;
		msg("creer_avions : goo_avions==NULL : c'est la premiere qu'on cree des avions\n");
		ancien_nb_avions = variables->avions_siml;
	}
	else
	{
		for(a=0;a<ancien_nb_avions;a++)
		{
			destroy_item(goo_avions[a]);
		}
		free(goo_avions);
		goo_avions = NULL;
		ancien_nb_avions = 0;
	}
	//balayer tableau
	for(a=0;a<variables->avions_siml;a++)
	{
		msg("creer_avionS,nb_avion:nbavions:%d:int_a=%d\n",variables->avions_siml,a);
		msg("creer_avions : avions[a]->identifiant==%d\n",variables->avion[a]->identifiant);
		goo_avions[a] = creer_avion(variables->avion[a]);
		msg("goo_avions[a]=%d\n",goo_avions[a]);
	}

	//faire executer une premier rafraichissement graphique des avions
	maj_affichage_avions();
}
